Lambda the Ultimate

We've seen the Santa Claus problem before, but that was a few Xmas's ago.

Jingle Bells: Solving the Santa Claus Problem in Polyphonic C#

I remember seeing a link on LtU to some lecture notes explaining that in (denotational?) semantics of simple imperative programming languages, the semantics would have a serious hole if parallel-or was not included; the strong-exists operator made things even better.
I have searched and searched the archives, and cannot find any post that remotely resembles this. Help!

An interesting CFP, that given the discussions here recently should interest at least a couple of readers.

I have a few friends that have severe repetitive stress injury and can effectively no longer type for long periods of type.

I'm trying to consider an environment and a language which would be suited to speech-to-text input. My first thought on the base language is Standard ML since definitions are self contained and require no "punctuation" e.g.

let x=5
let y=7

is valid and complete without double-semicolons at the end. Thus, you could say "let x be five, let y be seven" and produce the above code without too much interpolation.

That said, there would have to be a grammar that translated a precise speech into ML and to be really effective, the ML generated would have to be constantly reparsed and kept in a symbol-table state so that the speech processing program could use the inherent structure of the underlying language to disambiguate slurred or otherwise ambiguous speech. Another good reason to use Standard ML is that parsed ML contains more information than many other languages due to type-safety putting restrictions on variable/function usage -- more disambiguation possible.

Does anyone have any thoughts on other requirements for such a beast or pointers to research that has already been done that I might not find through an old-fashined ACM/Citeseer/DBLP search?

Non-Deterministic Interaction Nets

Abstract

The Interaction Nets (IN) of Lafont are a graphical formalism used to model parallel computation. Their genesis can be traced back to the Proof Nets of Linear Logic. They enjoy several nice theoretical properties, amongst them pure locality of interaction, strong confluence, computational completeness, syntactically-definable deadlock-free fragments, combinatorial completeness (existence of a Universal IN). They also have nice "pragmatic" properties: they are simple and elegant, intuitive, can capture aspects of computation at widely varying levels of abstraction. Compared to term and graph rewriting systems, INs are much simpler (a subset of such systems that imposes several constraints on the rewriting process), but are still computationally complete (can capture the lambda-calculus). INs are a refinement of graph rewriting which keeps only the essential features in the system.

Conventional INs are strongly confluent, and are therefore unsuitable for the modeling of non-deterministic systems such as process calculi and concurrent object-oriented programming. We study four diffrent ways of "breaking" the confluence of INs by introducing various extensions:

• IN with Multiple (reduction) Rules (INMR) Allow more than one reduction rule per redex.
• IN with Multiple Principal Ports (INMPP) Allow more than one active port per node.
• IN with MultiPorts (INMP) Allow more than one connection per port.
• IN with Multiple Connections (INMC) Allow hyper-edges (in the graph-theoretical sense), i.e. connections between more than two ports.

It'd be nice if there were a convenient way to link directly to a comment, i.e. have the comment titles be links to themselves or perhaps a small icon beside them. The anchors are there as the following link demonstrates, but the only way to get at them is by searching for the comment or constructing the link yourself (or at least those were the only ways I could find after a bit of trying).

http://lambda-the-ultimate.org/node/view/100#comment-873

[Edit: You can also get the links in collapsed views, but still...]

Herb Sutter has this fascinating article discussing the notion that programmers haven't really had to worry much about performance or concurrency because of Moore's Law. However the CPU makers are running out of ways to make CPUs faster, in terms of raw Mmhz, and instead will be reduced to opting for multi-cpu and multi-core approaches.

As a consequence he believes that concurrency will become a first class concern for more developers (including language designers) and language there will be a resurgence in interest in what he calls 'efficient languages'.

I'm currently doing a lot more work with highly concurrent GUI applications in Java and discovering that there's a shortage of sensible guidelines out there on designing applications in the face of pervasive multi-threading or even ways of re-organising standard design patterns like MVC to handle inter-thread communications.

Since the only mainstream language I know of with good concurrency features built in is Java 5 I'm left wondering how people handle these issues in other languages.

Does anyone know of any research about designing for concurrency in rich client applications? Ideally in a style that minimises the amount of locking involved?

Seasonal greetings to everybody, I am back from my vacation, and have a new urge to program and probably learn some new language in the process :-)

I am looking for a PL for programming an interactive simulation - not really a game, but a simple world with moving agents which can be influenced by the user (ask your children about hatching norns to get an idea :-) ).

The PL should probably actively support concurrency, pickling/unpickling, have good libraries for graphics/mouse/sound, and be reasonably fashionable.

I am currently hesitating between Erlang and Alice, any ideas?

Thanks!

The recent discussion of the Chinese natural language included some speculation about what CS would look like had it not been dominated by English discourse.

The critique was raised that one could postulate any number of alternate histories. However, we can do better than pure speculation by looking at natural-language-inspired Programming Languages developed in non-english-based cultures.

To date I have only come acrosss a few such references to Japanse-based experiments in End User friendly programming tools. Unfortunately, they refered to non-english papers that weren't accessible to anyone unable to cross the natural language barrier.

This work was of particular interest because it went beyond the mere transliteration of keywords in Western programming languages. But alas, the references I encountered were little more than second-hand existence proofs of work we should know more about.

If anyone is familar with such efforts, any information and observations you could share would be most deeply appreciated.

Peter J. Wasilko, Esq.
Executive Director & Chief Technology Officer
The Institute for End User Computing, Inc.

---

These comments are not official IEUC positions unless otherwise noted.

I just posted to SourceForge.net the YARD parser which is a public-domain generic recursive-descent parser for C++ which is available for dwonload at SourceForge.net, documentation is also available at http://yard-parser.sf.net. The YARD parser is intended primarily to be used as lexical analyzer and syntax parser, but it is a very general purpose library. The release includes a partial XML grammar and parser. The YARD parser is intended as a simpler alternative to the boost::spirit library. Any questions or comments are welcome.